package com.neusoft.liduan.d0916;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;

import com.neusoft.liduan.d0915.Line;

public class 集合 {
	/*	在Java中的集合
	 * 		集合与数组都是用来保存多个数据的，变量只能保存单个数据，数组的效率比集合高很多
	 * 		集合比数组使用起来更方便，比如ArrayList就是基于数组来实现的集合
	 * 		相关接口
	 * 			都在java.util包下
	 * 			集合的父类为Collection接口
	 * 				int size();返回集合的大小
	 * 				boolean isEmpty();是否是空集合即大小为0
	 * 				boolean contains(Object o);是否包含指定的对象
	 * 				Iterator<E> iterator();迭代器，用于遍历集合
	 * 				Object[] toArray();转换为数组
	 * 				<T> T[] toArray(T[] a);转换为数组，支持泛型
	 * 				boolean add(E e);添加元素
	 * 				boolean remove(Object o);移除元素
	 * 				boolean containsAll(Collection<?> c);是否包含另一个集合
	 * 				boolean addAll(Collection<? extends E> c);添加一个集合所有元素
	 * 				boolean removeAll(Collection<?> c);删除c集合中所有元素
	 * 				boolean removeIf(Predicate<? super E> filter)根据条件删除，属于Stream的方法，也是jdk8提供语法糖
	 * 				void clear();清空集合
	 * 				boolean equals(Object o);比较
	 * 			Set接口
	 * 				获取单元素，不方便
	 * 			List接口
	 * 				boolean addAll(int index, Collection<? extends E> c);在index位置添加c集合中的所有元素
	 * 				replaceAll(UnaryOperator<E> operator)替换
	 * 				sort(Comparator<? super E> c)：排序
	 * 				E get(int index);获取指定的index位置的元素
	 * 				E set(int index, E element);修改
	 * 				void add(int index, E element);
	 * 				E remove(int index);
	 * 				int indexOf(Object o);
	 * 				int lastIndexOf(Object o);
	 * 				ListIterator<E> listIterator(int index);迭代器
	 * 				List<E> subList(int fromIndex, int toIndex);截取集合
	 * 		相关实现类
	 * 			Set接口：
	 * 				HashSet，基于HashMap实现的，而HashMap是一个键值对的数组，即key-value
	 * 					Object clone()：复制对象
	 * 				遍历
	 * 					1、获取迭代器it
	 * 					2、while循环判断it.hashNext()方法
	 * 					3、通过it.next()方法获取元素
	 * 			Set集合不允许元素重复、元素的顺序不是由添加顺序来决定的、Set集合是通过Hashcode和equals方法来判断对象是否一样
	 * 			List接口
	 * 				ArrayList：是基于数组实现的
	 * 				List集合保留添加元素顺序，允许重复
	 * 				遍历有两种方式
	 * 					1、迭代器
	 * 					2、for和get方法
	 * 				LinkedList：每一个元素都知道它的上一个和下一个元素，类似火车，元素之间有关系
	 */
	public static void main(String[] args) {
		t4();
	}
	
	//HashSet
	public static void t1() {
		HashSet set = new HashSet();
		HashSet set1 = set;//请问这是clone吗？不是。set和set1指向同一个地址
		set.add(1);
		//遍历
		System.out.println("set1集合");
		it(set1);
		HashSet set2 = (HashSet) set.clone();//set2和set地址不一样
		System.out.println("set2");
		it(set2);
		set.add(1);
		set.add(2);//set集合有几个元素?
		System.out.println("修改后set集合");
		it(set);
		System.out.println("修改后set2");
		it(set2);
		set.add(10);
		set.add(8);
		set.add(9);
		System.out.println("元素顺序");
		it(set);//打的内容为什么
		//删除元素，基本数据类型元素和引用数据类型元素
		set.remove(10);
		//添加
		set.add(new Line());
		set.add(new Line());
		set.remove(new Line());//82到84创建了几个对象？84行是否删除了一个Line对象
		Line l1 = new Line(0,0,0,0);
		Line l2 = new Line(0,0,0,0);
		set.add(l1);
		set.add(l2);
		System.out.println("长度：" + set.size());
		set.remove(l1);
		System.out.println("长度：" + set.size());//7
//		Set set1 = new Set();//接口不能被实例化
		set.add(new Student("haha"));
		set.add(new Student("haha"));
		System.out.println("长度：" + set.size());
	}
	
	public static void it(HashSet set) {
		Iterator iterator = set.iterator();
		while(iterator.hasNext()) {
			System.out.println(iterator.next());
		}
	}
	
	public static void t2() {
		ArrayList al = new ArrayList();
		al.add(1);
		al.add(10);
		al.add(3);
		al.add(2);
		//遍历
		for (int i = 0; i < al.size(); i++) {
			System.out.println(al.get(i));
		}
		System.out.println("删除元素");
		al.remove(0);//删除第一个元素
		al.remove(2);//删除2这个元素
		for (int i = 0; i < al.size(); i++) {
			System.out.println(al.get(i));
		}
		//删除对象
		al.add(new Student("haha"));
		al.add(new Student("haha"));
		for (int i = 0; i < al.size(); i++) {
			System.out.println(al.get(i));
		}
		ArrayList al1 = new ArrayList();
		al1.addAll(al);
		System.out.println("al1的大小：" + al1.size());
		for (int i = 0; i < al1.size(); i++) {
			System.out.println(al1.get(i));
		}
		HashSet set = new HashSet();
		set.add(100);
		set.add(200);
		al1.addAll(set);
		System.out.println("al1的大小：" + al1.size());
		for (int i = 0; i < al1.size(); i++) {
			System.out.println(al1.get(i));
		}
	}
	
	public static void t3() {
		LinkedList ll = new LinkedList();
		ll.add(1);
		ll.add(10);
		ll.add(3);
		ll.add(2);
	}
	
	public static void t4() {
		/*	LinkedList和ArrayList之间的比较
		 * 		1、添加元素的效率
		 * 			LinkedList比ArrayList要高一些
		 * 		2、遍历的效率
		 * 			ArrayList比LinkedList高一截，差不多几千倍
		 */
		long t1 = System.currentTimeMillis();
		ArrayList la = new ArrayList();
		int len = 100000;
		for(int i = 0; i < len; i++) {
			la.add(i);
		}
		long t2 = System.currentTimeMillis();
		System.out.println("ArrayList的添加时间：" + (t2 - t1));
		
		t1 = System.currentTimeMillis();
		LinkedList ll = new LinkedList();
		for(int i = 0; i < len; i++) {
			ll.add(i);
		}
		t2 = System.currentTimeMillis();
		System.out.println("LinkedList的添加时间：" + (t2 - t1));

		t1 = System.currentTimeMillis();
		for(int i = 0; i < len; i++) {
			la.get(i);
		}
		t2 = System.currentTimeMillis();
		System.out.println("ArrayList的遍历时间：" + (t2 - t1));

		t1 = System.currentTimeMillis();
		for(int i = 0; i < len; i++) {
			ll.get(i);
		}
		t2 = System.currentTimeMillis();
		System.out.println("LinkedList的遍历时间：" + (t2 - t1));
	}
}
